# 函数(可以看作一段可以重复使用的代码)

# 内置函数
# input()函数
# user_input = input()
# print(f"你输入的内容是: {user_input}")
# name = input("请输入你的名字: ")
# print(f"你好, {name}!")

# eval()函数
# #eval表示evaluate
# 将字符串作为表达式进行求值，并返回计算结果
# result = eval('3 + 5')
# print(result)
# global_variable = {'a': 10, 'b': 20} # global variable全局变量，local variable局部变量
# result = eval('a + b',global_variable)
# print(result)

# print()函数
# a = 1
# print("a =", a)
# num = 42
# text = "is the answer"
# print(num, text) #值与值之间默认用空格分隔
# 使用 sep 参数指定分隔符
# print("apple", "banana", "cherry", sep=", ")
# 使用 end 参数指定结尾字符（默认是换行符 \n）
# print("This is the first line", end=" ") # 以空格结尾
# num1 = 5
# num2 = 3
# print(f"{num1} + {num2} = {num1 + num2}")
# str.format() 方法
# name = "Jack"
# age = 30
# print("My name is {} and I am {} years old.".format(name, age)) #{}为占位符
# print("{{}}") #{{}}输出花括号，没有{}的占位作用
# print("{},{},{}".format(1, 2*3, "hi"))
# print("{2},{1},{0}".format(1,2*3,"hi"))
# print("{0:-^8}".format("hi","python")) # ^表示居中对齐
# print("{0:-<8}".format("hi","python")) # <表示左对齐
# print("{0:->8}".format("hi","python")) # >表示右对齐
# print("{1:*^10}".format("hi","python"))
# print("{0:{1}^10} {2:{3}^10}".format("hi","-","python","*"))
# print("{:b},{:o},{:d},{:x},{:X},{:c}".format(74, 74, 74, 74, 74, 74 )) # 74对应的Unicode字符是J
# print("{:e},{:E},{:f},{:%}".format(0.12, 0.12, 0.12, 0.12 )) #浮点数输出默认有6位小数
# print("{:.2e},{:.2E},{:.2f},{:.2%}".format(0.12, 0.12, 0.12, 0.12 )) #只输出2位小数

# # abs(x) 取绝对值
# print(abs(-4)) # absolute value 绝对值
# # divmod(x, y) 返回(x//y,x%y)
# a = divmod(8, 5)
# print(a)
# #round(x) # 返回x小数部分四舍五入后的整数值
# # round(x, d) # 保留d位小数，d+1位小数四舍五入
# print(round(3.14))
# print(round(3.14, 0))
# print(round(3.14, 1))
# # 取大函数和取小函数
# max_num = max(1, -3, 0)
# min_str = min("apple", "orange", "banana") #逐字符按字典序比较，字符的比较是基于它们的 Unicode 码点
# # len() 返回字符串长度
# print(len("hello"))
# # str() 返回字符串形式
# print(str(3 * 4))
# # chr()返回Unicode对应的字符
# print(chr(97))
# # ord()返回字符对应的Unicode
# print(ord("0")) # ordinal序数
# # hex()返回十进制数对应的十六进制数的字符串形式 # hexadecimal 十六进制的
# print(hex(10))
# # oct()返回十进制数对应的十六进制数的字符串形式 # octal 八进制的
# print(oct(10))
# # 类型转换
# print(int(23.9)) #取整
# print(int("23"))
# print(float(23))
# print(complex(1, 2)) #返回(1+2j)复数带括号





# 自定义函数

# def calc_sum(beg, end): # 定义一个求和函数
#     Sum = 0
#     for i in range(beg, end + 1):
#         Sum += i
#     print(f"求和结果为：{Sum}")
# calc_sum(1, 100) # 调用函数

# # 函数的语法格式
"""1.函数的定义（分配任务）
  def 函数名（形参列表）： #形参即形式参数，（）里也可以没有形参
    函数体
    return 返回值 #返回值是函数的运算结果，return语句不是必须有
2.函数的调用（执行任务）
  (1)函数名（实参列表） #实参即实际参数
  (2)返回值 = 函数名（实参列表）
注：函数不调用就不会执行
   定义要在调用之前
"""
from itertools import count

# # 函数参数传递
# def cal_sum(n1, n2):
#     s = 0
#     for i in range(n1, n2 + 1):
#         s += i
#     return s
#
# # 1.按变量位置传参
# m1 = 1
# m2 = 10
# Sum = cal_sum(m1, m2)
# print(Sum)
# # 2.按变量名传参
# Sum = cal_sum(n2 = 10, n1 = 1)
# print(Sum)
# # 3.按默认值传参（有默认值的参数放要在最后）
# def cal_sum(n2, n1 = 1):
#     s = 0
#     for i in range(n1, n2 + 1):
#         s += i
#     return s
#
# Sum1 = cal_sum(n2 = 10)
# Sum2 = cal_sum(n2 = 10, n1 = 2)
# print(Sum1, Sum2)
# # 4.数量可变的参数传递
# def count(*x):
#     for i in x:
#         print('{:^6}'.format(i), end='')
#     return len(x)
#
# people = count('Jack', 'Mike')
# print('共{}人'.format(people))
#
# def total_values(**x):
#     total = 0
#     print(x)
#     for v in x.values():
#         total += v
#     return total
#
# print(total_values(group1 = 10, group2 = 20))



# def Add(a, b, c):
#     print(a, b, c)
# Add(1, 'Hello', True) # Python中形参和实参个数要求一样，类型无硬性要求
# def add(x, y):
#     return x + y
# 将运算和打印分开其实是让 逻辑 与 交互/界面 分离，解耦合
# a = add(10, 20)
# print(a)
# print(add('hello','world'))

# #一般多个 return 语句是搭配分支语句/循环语句的
# def isOdd(num):
#     if num % 2 == 0:
#         return False
#     else:
#         return True
# def isOdd(num):
#     if num % 2 == 0:
#         return False
#     return True # return 了 False 就不会 return True
# Python中一个函数能返回多个值

# def getPoint():
#     x = 10
#     y = 20
#     z = 30
#     return x, y, z
# a, b , c = getPoint()
# print((a, b ,c))
# _, _, d = getPoint() # _用来占位



#变量作用域
# x = 10 #全局变量
# def test():
#     x = 20 #局部变量
#     print(f"函数内部：{x}")
# test()
# print(f"函数外部：{x}")
# y =1
# def f():
#     print(y) #函数在内部读取不到局不变量，则会读取全局变量
# f()
# z = 1
# def g(): #此函数可将全局变量变成 2
#     global z  # global是声明全局变量的关键字
#     z = 2
# g()
# print(z)

# 函数的链式调用（将一个函数的返回值作为另一个函数的参数）
# def isOdd(num):
#     if num % 2 == 0:
#         return False
#     return True
# def add(x, y):
#     return x + y
# print(isOdd(add(5, 5)))

# 函数的嵌套调用（在一个函数内部调用另一个函数）
# def a():
#     print("a")
# def b():
#     print("b")
#     a()
# def c():
#     print("c")
#     b()
# c()
# def a():
#     print("a")
# def b():
#     a()
#     print("b")
# def c():
#     b()
#     print("c")
# c()

# 函数递归（调用自己）
# 递归代码容易出现“栈（函数的调用栈）溢出”的情况（无法达到递归结束的条件）
# def factor(n):
#     result = 1
#     for i in range(1, n + 1):
#         result *= i
#     return result
#
# print(factor(5))
# def f(n):
#     result = 1
#     if n == 1:
#         return 1
#     return n * f(n - 1)
# print(f(5))

# # 带默认值的形参（可以有多个）
# def add(x, y, debug=False): # 带默认值的形参必须写在后面
#     if debug:
#         print(f"x = {x}, y = {y}")
#     return x + y
# print(add(1, 2)) # 带有默认值的形参不必传参
# print(add(3, 4, True))
# print(add(debug=True,y =5, x = 6))  #关键字传参